எடுத்துக்காட்டு: Node.js க்கான அடிப்படை Dockerfile

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .

EXPOSE 8080

CMD ["node", "app.js"]

# Build the image
docker build -t my-nodejs-app .

# Run the container
docker run -p 8080:8080 my-nodejs-app

எடுத்துக்காட்டு: பல-நிலை Dockerfile

# Build stage
FROM node:20-alpine AS build

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# Production stage
FROM node:20-alpine

WORKDIR /app
COPY --from=build /app/node_modules ./node_modules
COPY . .

# Set NODE_ENV
ENV NODE_ENV=production

# Non-root user for security
USER node

EXPOSE 8080
CMD ["node", "app.js"]

எடுத்துக்காட்டு: docker-compose.yml

version: '3.8'

services:
  # Node.js application
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - NODE_ENV=production
      - DB_HOST=db
      - DB_USER=user
      - DB_PASSWORD=password
      - DB_NAME=myapp
    depends_on:
      - db
    restart: unless-stopped

  # Database
  db:
    image: postgres:14
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=myapp
    restart: unless-stopped

volumes:
  postgres_data:

# Start all services
docker-compose up

# Start in detached mode
docker-compose up -d

# Stop all services
docker-compose down

எடுத்துக்காட்டு: deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nodejs-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nodejs-app
  template:
    metadata:
      labels:
        app: nodejs-app
    spec:
      containers:
      - name: nodejs-app
        image: your-registry/nodejs-app:latest
        ports:
        - containerPort: 8080
        env:
        - name: NODE_ENV
          value: "production"
        resources:
          limits:
            cpu: "500m"
            memory: "512Mi"
          requests:
            cpu: "200m"
            memory: "256Mi"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10

எடுத்துக்காட்டு: service.yaml

apiVersion: v1
kind: Service
metadata:
  name: nodejs-service
spec:
  selector:
    app: nodejs-app
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

# Install Heroku CLI
npm install -g heroku

# Login to Heroku
heroku login

Procfile

web: node app.js

# Initialize Git if needed
git init
git add .
git commit -m "Initial commit"

# Create a Heroku app
heroku create my-nodejs-app

# Deploy to Heroku
git push heroku main

# Scale your app (optional)
heroku ps:scale web=1

# Open your app in browser
heroku open

எடுத்துக்காட்டு: சூழல் கட்டமைப்புடன் app.js

const express = require('express');
const app = express();

// Environment variables with fallbacks
const PORT = process.env.PORT || 8080;
const NODE_ENV = process.env.NODE_ENV || 'development';
const DB_URI = process.env.DB_URI || 'mongodb://localhost:27017/myapp';

app.get('/', (req, res) => {
  res.send(`Hello from ${NODE_ENV} environment!`);
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT} in ${NODE_ENV} mode`);
});

எளிய AWS Lambda செயல்பாடு (handler.js)

module.exports.hello = async (event) => {
  const name = event.queryStringParameters?.name || 'World';

  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(
      {
        message: `Hello, ${name}!`,
        timestamp: new Date().toISOString(),
      },
    ),
  };
};

serverless.yml

service: my-nodejs-api

provider:
  name: aws
  runtime: nodejs16.x
  region: us-east-1
  environment:
    NODE_ENV: production

functions:
  hello:
    handler: handler.hello
    events:
      - http:
          path: hello
          method: get
          cors: true

  getUser:
    handler: users.getUser
    events:
      - http:
          path: users/{id}
          method: get
          cors: true

.github/workflows/deploy.yml

name: Deploy Node.js Application

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Use Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16.x'
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test
      - name: Run linting
        run: npm run lint

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to production
        uses: some-action/deploy-to-cloud@v1
        with:
          api-key: ${{ secrets.DEPLOY_API_KEY }}
          app-name: my-nodejs-app
          environment: production

main.tf

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "nodejs_server" {
  ami = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"

  tags = {
    Name = "nodejs-app-server"
  }

  user_data = <<-EOF
    #!/bin/bash
    curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -
    sudo apt-get install -y nodejs
    mkdir -p /app
    cd /app
    echo 'console.log("Hello from Node.js");' > app.js
    node app.js
    EOF
}

resource "aws_security_group" "app_sg" {
  name = "app-security-group"
  description = "Allow web traffic"

  ingress {
    from_port = 80
    to_port = 80
    protocol = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port = 22
    to_port = 22
    protocol = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port = 0
    to_port = 0
    protocol = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

worker.js

// Handle incoming requests
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  // Get visitor's country from Cloudflare headers
  const country = request.cf.country || 'unknown';

  // Custom response based on location
  const html = `
    
    
    
      
    
    
      
Hello from ${country}!
      
Served from ${new Date().toISOString()}
    
    `;

  return new Response(html, {
    headers: { 'content-type': 'text/html;charset=UTF-8' },
  });
}

middleware.js

import { NextResponse } from 'next/server';

// Runs on every request to your site
export function middleware(request) {
  // Get the user's country from the request
  const country = request.geo.country || 'US';

  // Rewrite to a country-specific page if needed
  if (country === 'GB') {
    return NextResponse.rewrite('/uk-home');
  }

  // Add a custom header
  const response = NextResponse.next();
  response.headers.set('x-edge-runtime', 'true');

  return response;
}

// Only run on specific paths
export const config = {
  matcher: ['/', '/about/:path*'],
};